import * as util from "../utils/index基础"
import { toRaw } from "vue"

// export function 组转对象增(obj, 初始对象) {
// 	const 对象 = {}
// 	for (let item of arr) {
// 		if (item.id in 对象) {
// 			// 已经存在
// 			break
// 		} else {
// 			对象[item.id] = 初始对象;
// 		}
// 	}
// 	return 对象
// }

// export function 组转对象(arr, 初始对象) {
// 	const 对象 = {}
// 	for (let item of arr) {
// 		if (item.id in 对象) {
// 			// 已经存在
// 			console.log('组转对象: item.id 已经存在', item.id);
// 			break
// 		} else {
// 			console.log('组转对象: item.id 不存在', item.id);
// 			对象[item.id] = 初始对象;
// 		}
// 	}
// 	return 对象
// }


export function 是数组包对象(arr) {
	return Array.isArray(arr) && arr.every(item => util.是对象(item))
}

export function 某对象等于某值否(范围arr, 属性名, 关键词) {
	// console.log('含其中之一 str: ', str);
	const res = 范围arr.some(item => {
		// console.log('关键词: ', item);
		return item[属性名] == 关键词
	})
	return res
}

export function 累加(arr, 字段) {
	return arr.reduce((prev, next) => {
		return (prev += Number(next[字段] || 0))
	}, 0)
}

export function 累加前几个(arr, 字段, 个数 = 7) {
	const res = arr.slice(0, 个数).reduce((acc, curr) => acc + (curr[字段] || 0), 0)
	return res
}

export function 含其中哪个(str, 关键词组) {
	let 含哪个 = ""
	// const 含 = 关键词组.some((item) => {
	// 	return str.includes(item);
	// });
	for (let item of 关键词组) {
		if (str.includes(item)) {
			含哪个 = item
			return 含哪个
		}
	}
	return 含哪个
}

/**非包含关系,就是要精确相等👇 */
export function 含其中之一(str, 关键词组, 包含关系 = true) {
	// console.log('含其中之一 str: ', str);
	const 含 = 关键词组.some(item => {
		// console.log('关键词: ', item);
		if (包含关系) {
			return str.includes(item)
		} else {
			return str == item
		}
	})
	// console.log('含: ', 含);
	return 含
}

export function 其中之一包含(arr, 关键词组) {
	const 含 = arr.some(item => {
		const 某个关键词是否包含 = 关键词组.some(关键词 => {
			// console.log('关键词: ', 关键词);
			// console.log('item: ', item);
			return item.includes(关键词)
		})
		return 某个关键词是否包含
	})
	return 含
}

export function 都包含(arr, 关键词组) {
	const 含 = 关键词组.every(关键词 => {
		return arr.includes(关键词)
	})
	return 含
}

export const 找label = (源arr, 关键词或组) => {
	if (Array.isArray(关键词或组)) {
		return 关键词或组.map(关键词 => {
			return 找label单个(源arr, 关键词)
		})
	}
	return 找label单个(源arr, 关键词或组)
}

const 找label单个 = (源arr, 关键词) => {
	// console.log(`找label单个 源arr 👉`,源arr)
	// console.log(`关键词 👉`,关键词)
	const res = 源arr && 源arr.find(item => item.value === 关键词)
	return res?.label
}

export function 添加非重复元素(arr, item) {
	let index = arr.indexOf(item)
	if (index == -1) {
		arr.push(item)
	}
}

export function 取最末元素(req) {
	if (!Array.isArray(req)) return req
	const res = req.at(-1)
	return res
}

export function 转tree(data, idKey = "id", parentKey = "父级id") {
	// 创建一个以 id 为键的对象，用于快速访问
	const idMap = {}
	data.forEach(item => {
		idMap[item[idKey]] = { ...item, children: [] } // 初始化每个节点的 children 数组
	})
	// console.log(`idMap 👉`,idMap)
	const tree = []

	data.forEach(item => {
		// console.log(`item 👉`,item)
		if (item[parentKey] === null) {
			// 如果没有父级，说明是根节点
			tree.push(idMap[item[idKey]])
		} else if (idMap[item[parentKey]]) {
			// 如果有父级，添加到其父级的 children 数组
			idMap[item[parentKey]].children.push(idMap[item[idKey]])
		}
	})

	return tree
}

export function 数组差集(array1, array2) {
	const res = array1.filter(item => !array2.includes(item))
	return res
}

export function 数组交集(array1, array2) {
	const 交集 = array1.filter(item => array2.includes(item))
	return 交集
}

export function 是否有某个以字符结尾(arr, 关键词) {
	return arr.some(item => {
		return item.endsWith(String(关键词))
	})
}

export function 删除元素(arr, 关键词或元素, 字段 = "id") {
	let index = arr.findIndex(item => item?.[字段] === 关键词或元素)
	if (index == -1) {
		index = arr.indexOf(关键词或元素)
	}
	if (index !== -1) {
		arr.splice(index, 1)
	}
}

export function 数组属性排序(arr, 字段 = "id", 倒序 = false) {
	// 会直接修改原数据
	// console.log('数组属性排序ing 字段: ', 字段);
	// console.log('排序前 arr: ', arr);
	arr.sort((a, b) => {
		// 下面漏了return 就等于白干了
		// console.log('a[字段]: ', a[字段]);
		// console.log('b[字段]: ', b[字段]);
		let 比较结果 = a[字段] - b[字段]
		if (typeof a[字段] === "string") {
			比较结果 = a[字段].localeCompare(b[字段])
		}
		// console.log('比较结果: ', 比较结果);
		return 比较结果
	})
	if (倒序) {
		arr.reverse()
	}
	// return arr
}

export const 数组全中 = (arr, 大数组) => {
	return arr.every(item => 大数组.includes(item))
}

export const 清除非中文 = arr => {
	const filteredArr = arr.filter(item => /^[\u4e00-\u9fa5]+$/.test(item))
	return filteredArr
}

export function 找子级s(范围arr, 查找id) {
	let 子级s = 范围arr.filter(i => i.parentId == 查找id)
	return 子级s
}

export function 查元素(arr, 关键词, 字段 = "id", 包含关系 = false) {
	let item
	if (包含关系) {
		item = arr.find(item => item[字段].includes(关键词))
	} else {
		item = arr.find(item => item[字段] === 关键词)
	}
	return item
}

export function 查找元素(arr, 关键词, 字段 = "id") {
	const item = arr.find(item => item[字段] === 关键词)
	return item
}

export function 查找元素序号(arr, 关键词, 字段 = "id") {
	const index = arr.findIndex(item => {
		// console.log(`item[字段] 👉`, item[字段])
		return item[字段] === 关键词
	})
	return index
}

export function 数组重予(源数组, 新数组) {
	// 清空
	源数组.length = 0
	if (新数组 && 新数组.length > 0) {
		源数组.push(...新数组)
	}
}

export function 按给定数组顺序排序(arr, 排序数组, 字段 = "名称") {
	arr.sort((a, b) => {
		return 排序数组.indexOf(a[字段]) - 排序数组.indexOf(b[字段])
	})
}

export const 数组元素转对象 = arr => {
	return arr.map((item, index) => {
		const obj = {}
		obj.value = item
		obj.text = item
		return obj
	})
}

export const 数组中取属性组 = (arr, 字段) => {
	if (!arr) return
	const result = [...new Set(arr.map(item => item[字段]))]
	return result
}

export const 数组过滤 = (范围, 字段, 关键词, 包含关系 = false) => {
	let s = []
	if (!包含关系) {
		s = 范围.filter(obj => obj[字段] == 关键词)
	} else {
		s = 范围.filter(obj => {
			// console.log('关键词: ', 关键词);
			// console.log('字段: ', 字段);
			// console.log('obj[字段]: ', obj[字段]);
			return String(obj[字段]).includes(关键词)
		})
	}
	return s
}

export const 数组过滤一排除 = (范围, 字段, 关键词, 包含关系 = false) => {
	if (!范围) return
	let res
	if (!包含关系) {
		if (typeof 关键词 === "string") {
			res = 范围.filter(obj => obj[字段] != 关键词)
		} else if (Array.isArray(关键词)) {
			res = 范围.filter(obj => {
				let 值 = obj[字段]
				let 关键词组 = 关键词
				let res2 = 含其中之一(值, 关键词组, 包含关系)
				return !res2
			})
		}
	} else {
		res = 范围.filter(obj => !String(obj[字段]).includes(关键词))
	}
	return res
}